package com.tjn.thread;

/**
 * @author 陶镓妮
 * @version 1.0
 */
public class ThreadRunnable02 {
    public static void main(String[] args) {
        //如果现在有个类想要继承Thread类，但是这个类已经继承了其他的类，就不能继承Thread类，这时就可以使用Runnable接口
        Dog dog = new Dog();
        //dog.start();//这里不能调用start方法，因为start方法属于Thread类，Runnable接口里面没有start方法
        //可以使用Thread类的构造方法，将Runnable接口的实现类对象作为参数传递
        Thread thread = new Thread(dog);//为了方便理解，模拟一个简单的Thread类
        thread.start();
        //这里dog传到底层的Thread构造器，会把dog赋给target，dog的返回类型是Dog，target的返回类型是Runnable,
        //因为Dog类是实现了Runnable接口的，所以dog传进target的运行类型会变成Dog，这个过程是向上转型，这时编译类型是Runnable,运行类型则是 Dog
        //调用start方法时，会调用start0方法，start0方法会调用run方法，run方法会调用target的run方法，通过动态绑定调用Dog类中的run方法

//        Tiger tiger = new Tiger();
//        ThreadProxy threadProxy = new ThreadProxy(tiger);
//        threadProxy.start();
    }
}
class Animal{}
class Tiger extends Animal implements Runnable{
    @Override
    public void run() {
        System.out.println("老虎叫。。。");
    }
}

//线程代理类，模拟一个简单的Thread类
class ThreadProxy implements Runnable{
    private Runnable target;
    @Override
    public void run() {
        if(target != null){
            target.run();//动态绑定，运行类型为Tiger
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }
    public void start(){
        start0();
    }
    public void start0(){
        run();
    }
}


class Dog implements Runnable{//通过实现Runnable接口，创建一个线程

    @Override
    public void run() {
        int count = 0;
        while(true){
            System.out.println("汪汪汪。。。" + (++count) + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if(count == 60){
                break;
            }
        }

    }
}